package visiopuce.ui.view;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;

import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.jface.action.IMenuListener;
import org.eclipse.jface.action.IMenuManager;
import org.eclipse.jface.action.MenuManager;
import org.eclipse.jface.dialogs.IDialogConstants;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.resource.JFaceResources;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.TreeViewer;
import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.SashForm;
import org.eclipse.swt.events.ModifyEvent;
import org.eclipse.swt.events.ModifyListener;
import org.eclipse.swt.events.MouseEvent;
import org.eclipse.swt.events.MouseListener;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.events.SelectionListener;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Event;
import org.eclipse.swt.widgets.Group;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Link;
import org.eclipse.swt.widgets.Listener;
import org.eclipse.swt.widgets.Menu;
import org.eclipse.swt.widgets.TabFolder;
import org.eclipse.swt.widgets.Text;
import org.eclipse.swt.widgets.ToolBar;
import org.eclipse.swt.widgets.ToolItem;
import org.eclipse.ui.IEditorInput;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.IEditorSite;
import org.eclipse.ui.IPartListener2;
import org.eclipse.ui.IWorkbenchPage;
import org.eclipse.ui.IWorkbenchPartReference;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.PartInitException;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.part.EditorPart;
import org.eclipse.wb.swt.ResourceManager;

import visiopuce.ApplicationContexte;
import visiopuce.action.ActionSupprimer;
import visiopuce.objets.Alteration;
import visiopuce.objets.Analyse;
import visiopuce.objets.ExpFish;
import visiopuce.objets.Famille;
import visiopuce.objets.NonConformite;
import visiopuce.objets.Personne;
import visiopuce.objets.Prelevement;
import visiopuce.objets.Puce;
import visiopuce.objets.RenduBiomol;
import visiopuce.objets.RenduFish;
import visiopuce.objets.RenduPuce;
import visiopuce.objets.Resultat;
import visiopuce.objets.Utilisateur;
import visiopuce.objets.VerifBiomol;
import visiopuce.objets.VerifFish;
import visiopuce.objets.ZoneTesteeBiomol;
import visiopuce.service.AlterationServiceImpl;
import visiopuce.service.AnalyseServiceImpl;
import visiopuce.service.DroitServiceImpl;
import visiopuce.service.EnModifServiceImpl;
import visiopuce.service.FamilleServiceImpl;
import visiopuce.service.NonConformiteServiceImpl;
import visiopuce.service.PersonneServiceImpl;
import visiopuce.service.PrelevementServiceImpl;
import visiopuce.service.PuceServiceImpl;
import visiopuce.service.ResultatServiceImpl;
import visiopuce.ui.CotationDialog;
import visiopuce.ui.DossierEditorInput;
import visiopuce.ui.FamilleDialog;
import visiopuce.ui.NonConformiteDialog;
import visiopuce.ui.listener.DoubleClickNavigationListener;
import visiopuce.ui.providers.NavigationContentProvider;
import visiopuce.ui.providers.NavigationLabelProvider;
import visiopuce.ui.tree.AnalyseNode;
import visiopuce.ui.tree.DossierNode;
import visiopuce.ui.tree.PrelevementNode;
import visiopuce.ui.tree.PuceNode;
import visiopuce.ui.tree.ResultatNode;
import visiopuce.ui.tree.TreeNode;

public class DossierEditor extends EditorPart implements IPartListener2 {

	public static final String ID = "visiopuce.dossierEditor";
	private TreeViewer treeViewer;
	protected boolean isDirty = false;
	private DossierEditorInput dossierEditorInput;
	private TabFolder tabFolder;
	private DossierTabItem dossierTabItem;
	private HashMap<Integer, PrelevementTabItem> prelevementTabItems;
	private HashMap<Integer, AnalyseTabItem> analyseTabItems;
	private HashMap<Integer, CNVTabItem> cnvTabItems;
	private HashMap<Integer, PuceTabItem> puceTabItems;
	private SashForm sashForm_1;
	private ToolItem itemModifier;
	private boolean isModifiable;
	private ToolItem itemSave;
	private Puce newp = null;
	private Group gFamille;
	private Label lPersonne;
	private Text tCommentaire;
	private org.eclipse.swt.widgets.List listNonConformite;
	private Button btnAjouterUneNonConf;

	public DossierEditor() {

	}

	@Override
	public void createPartControl(Composite parent) {
		isModifiable = false;
		if (dossierEditorInput.getPersonneCourante().getIdPersonne() == 0) {
			isModifiable = true;
		}
		sashForm_1 = new SashForm(parent, SWT.NONE);

		createTree(sashForm_1);

		tabFolder = new TabFolder(sashForm_1, SWT.BOTTOM);
		tabFolder.addListener(SWT.Selection, new Listener() {

			public void handleEvent(Event event) {

				refresh();

			}

		});

		dossierTabItem = new DossierTabItem(tabFolder, SWT.NONE, isModifiable);
		sashForm_1.setWeights(new int[] { 162, 595 });
		dossierTabItem.remplir(dossierEditorInput.getPersonneCourante());
		dossierTabItem.getTabItem().getParent().pack();
		dossierTabItem.getTabItem().setToolTipText("" + dossierEditorInput.getPersonneCourante().getIdPersonne());
		final IWorkbenchWindow workbenchWindow = getSite().getWorkbenchWindow();
		workbenchWindow.getPartService().addPartListener(this);

	}

	public void addPrelevementTabItem(Prelevement prelevement) {
		if (DroitServiceImpl.getInstance().peutLireByUtilisateurAndChamp(ApplicationContexte.getInstance().getUtilisateur(), "prelevement")) {

			PrelevementTabItem prelevementTabItem;
			if (prelevement.getIdPrelevement() == 0) {
				setModifiable(true);
			}
			try {
				prelevementTabItem = prelevementTabItems.get(prelevement.getIdPrelevement());
				if (prelevementTabItem == null) {

					prelevementTabItem = new PrelevementTabItem(tabFolder, SWT.NONE, isModifiable);
					prelevementTabItems.put(prelevement.getIdPrelevement(), prelevementTabItem);
				}
			} catch (IndexOutOfBoundsException e) {
				prelevementTabItem = new PrelevementTabItem(tabFolder, SWT.NONE, isModifiable);
				prelevementTabItems.put(prelevement.getIdPrelevement(), prelevementTabItem);

			} catch (NullPointerException e) {
				prelevementTabItem = new PrelevementTabItem(tabFolder, SWT.NONE, isModifiable);
				prelevementTabItems.put(prelevement.getIdPrelevement(), prelevementTabItem);

			}
			prelevementTabItem.remplir(prelevement);
		}
	}

	public void addCNVTabItem(Alteration alteration) {
		if (DroitServiceImpl.getInstance().peutLireByUtilisateurAndChamp(ApplicationContexte.getInstance().getUtilisateur(), "alteration")) {

			CNVTabItem cnvTabItem;
			if (alteration.getIdAlteration() == 0) {
				setModifiable(true);
			}
			try {
				cnvTabItem = cnvTabItems.get(alteration.getIdAlteration());
				if (cnvTabItem == null) {
					cnvTabItem = new CNVTabItem(tabFolder, SWT.NONE, isModifiable);
					cnvTabItems.put(alteration.getIdAlteration(), cnvTabItem);
				}
			} catch (NullPointerException e) {
				cnvTabItem = new CNVTabItem(tabFolder, SWT.NONE, isModifiable);
				cnvTabItems.put(alteration.getIdAlteration(), cnvTabItem);

			} catch (IndexOutOfBoundsException e) {
				cnvTabItem = new CNVTabItem(tabFolder, SWT.NONE, isModifiable);
				cnvTabItems.put(alteration.getIdAlteration(), cnvTabItem);

			}
			cnvTabItem.remplir(alteration);

		}
	}

	public void addPuceTabItem(Puce puce) {
		if (DroitServiceImpl.getInstance().peutLireByUtilisateurAndChamp(ApplicationContexte.getInstance().getUtilisateur(), "puce")) {

			PuceTabItem puceTabItem;
			if (puce.getIdPuce() == 0) {
				setModifiable(true);
			}
			try {
				puceTabItem = puceTabItems.get(puce.getIdPuce());
				if (puceTabItem == null) {
					puceTabItem = new PuceTabItem(tabFolder, SWT.NONE, isModifiable);
					puceTabItems.put(puce.getIdPuce(), puceTabItem);
				}
			} catch (IndexOutOfBoundsException e) {
				puceTabItem = new PuceTabItem(tabFolder, SWT.NONE, isModifiable);
				puceTabItems.put(puce.getIdPuce(), puceTabItem);

			} catch (NullPointerException e) {
				puceTabItem = new PuceTabItem(tabFolder, SWT.NONE, isModifiable);
				puceTabItems.put(puce.getIdPuce(), puceTabItem);

			}
			puceTabItem.remplir(puce);
		}
	}

	public void addAnalyseTabItem(Analyse analayse) {
		if (DroitServiceImpl.getInstance().peutLireByUtilisateurAndChamp(ApplicationContexte.getInstance().getUtilisateur(), "analyse")) {

			AnalyseTabItem analyseTabItem;
			if (analayse.getIdAnalyse() == 0) {
				setModifiable(true);
			}
			try {
				analyseTabItem = analyseTabItems.get(analayse.getIdAnalyse());
				if (analyseTabItem == null) {
					analyseTabItem = new AnalyseTabItem(tabFolder, SWT.NONE, isModifiable);
					analyseTabItems.put(analayse.getIdAnalyse(), analyseTabItem);
				}
			} catch (NullPointerException e) {
				analyseTabItem = new AnalyseTabItem(tabFolder, SWT.NONE, isModifiable);
				analyseTabItems.put(analayse.getIdAnalyse(), analyseTabItem);

			} catch (IndexOutOfBoundsException e) {
				analyseTabItem = new AnalyseTabItem(tabFolder, SWT.NONE, isModifiable);
				analyseTabItems.put(analayse.getIdAnalyse(), analyseTabItem);

			}
			analyseTabItem.remplir(analayse);
		}
	}

	public DossierTabItem getDossierTabItem() {
		return dossierTabItem;
	}

	public void setDossierTabItem(DossierTabItem dossierTabItem) {
		this.dossierTabItem = dossierTabItem;
	}

	public HashMap<Integer, PrelevementTabItem> getPrelevementTabItems() {
		return prelevementTabItems;
	}

	public void setPrelevementTabItems(HashMap<Integer, PrelevementTabItem> prelevementTabItems) {
		this.prelevementTabItems = prelevementTabItems;
	}

	public HashMap<Integer, AnalyseTabItem> getAnalyseTabItems() {
		return analyseTabItems;
	}

	public void setAnalyseTabItems(HashMap<Integer, AnalyseTabItem> analyseTabItems) {
		this.analyseTabItems = analyseTabItems;
	}

	public HashMap<Integer, CNVTabItem> getCNVTabItems() {
		return cnvTabItems;
	}

	public void setCNVTabItems(HashMap<Integer, CNVTabItem> cnvTabItems) {
		this.cnvTabItems = cnvTabItems;
	}

	public HashMap<Integer, PuceTabItem> getPuceTabItems() {
		return puceTabItems;
	}

	public void setPuceTabItems(HashMap<Integer, PuceTabItem> puceTabItems) {
		this.puceTabItems = puceTabItems;
	}

	public TabFolder getTabFolder() {
		return tabFolder;
	}

	public void setTabFolder(TabFolder tabFolder) {
		this.tabFolder = tabFolder;
	}

	private void createTree(SashForm sashForm) {

		Composite c = new Composite(sashForm, SWT.NONE);
		c.setLayout(new GridLayout(1, false));

		// // final ScrolledComposite sc1 = new
		// // ScrolledComposite(sashForm.getShell(), SWT.H_SCROLL | SWT.V_SCROLL
		// |
		// // SWT.BORDER);
		// Composite c = new Composite(sashForm, SWT.V_SCROLL);
		// // sc1.setContent(c);
		// // sc1.getVerticalBar().setIncrement(10);
		// // sc1.getHorizontalBar().setIncrement(10);
		// // sc1.setAlwaysShowScrollBars(true);
		// // sashForm.getShell().setControl(sc1);
		// c.setLayout(new GridLayout(1, false));

		ToolBar toolBar = new ToolBar(c, SWT.FLAT | SWT.RIGHT);

		itemSave = new ToolItem(toolBar, SWT.PUSH);
		itemSave.setImage(ResourceManager.getPluginImage("visiopuce", "icons/enregistrer.jpg"));
		itemSave.setToolTipText("Enregistrer le dossier");
		itemSave.setEnabled(false);
		itemSave.addSelectionListener(new SelectionListener() {

			public void widgetSelected(SelectionEvent e) {
				// passer en mode écriture
				if (isDirty()) {
					doSave(null);
				}
			}

			public void widgetDefaultSelected(SelectionEvent e) {
				// TODO Auto-generated method stub

			}
		});

		itemModifier = new ToolItem(toolBar, SWT.CHECK);

		// itemModifier.setImage(ResourceManager.getPluginImage("visiopuce",
		// "icons/modifier.png"));
		if (isModifiable()) {
			itemModifier.setToolTipText("Dossier en édition, cliquez ici pour passer en mode lecture seule");
			itemModifier.setImage(ResourceManager.getPluginImage("visiopuce", "icons/unlock.jpg"));
		} else {
			itemModifier.setToolTipText("Dossier en lecture seule, cliquez ici pour passer en mode écriture");
			itemModifier.setImage(ResourceManager.getPluginImage("visiopuce", "icons/lock.jpg"));
		}
		itemModifier.addSelectionListener(new SelectionListener() {

			public void widgetSelected(SelectionEvent e) {
				// passer en mode écriture
				if (!isModifiable()) {
					setModifiable(true);
				} else {
					setModifiable(false);
				}
			}

			public void widgetDefaultSelected(SelectionEvent e) {
				// TODO Auto-generated method stub

			}
		});

		ToolItem itemCotation = new ToolItem(toolBar, SWT.PUSH);
		itemCotation.setImage(ResourceManager.getPluginImage("visiopuce", "icons/cotation.jpg"));
		itemCotation.setToolTipText("Ouvrir la fenetre de cotation du dossier");
		itemCotation.addSelectionListener(new SelectionListener() {

			public void widgetSelected(SelectionEvent e) {
				CotationDialog cotationDialog = new CotationDialog(getSite().getShell(), dossierEditorInput.getPersonneCourante(), null);
				cotationDialog.open();
			}

			public void widgetDefaultSelected(SelectionEvent e) {
				// TODO Auto-generated method stub

			}
		});

		treeViewer = new TreeViewer(c, SWT.MULTI | SWT.H_SCROLL | SWT.V_SCROLL | SWT.BORDER);
		treeViewer.setContentProvider(new NavigationContentProvider());
		treeViewer.setLabelProvider(new NavigationLabelProvider());
		GridData gd = new GridData(SWT.LEFT, SWT.CENTER, false, false, 1, 1);
		gd.heightHint = 200;
		treeViewer.getTree().setLayoutData(gd);
		treeViewer.setInput(new DossierNode(dossierEditorInput.getPersonneCourante()));
		treeViewer.expandAll();

		treeViewer.addDoubleClickListener(new DoubleClickNavigationListener());
		MenuManager menuMgr = new MenuManager();

		Menu menu = menuMgr.createContextMenu(treeViewer.getControl());
		menuMgr.addMenuListener(new IMenuListener() {
			@Override
			public void menuAboutToShow(IMenuManager manager) {
				// IWorkbench wb = PlatformUI.getWorkbench();
				// IWorkbenchWindow win = wb.getActiveWorkbenchWindow();
				if (treeViewer.getSelection().isEmpty()) {
					return;
				}

				IStructuredSelection selection = (IStructuredSelection) treeViewer.getSelection();
				StringBuffer toShow = new StringBuffer();
				for (Iterator iterator = selection.iterator(); iterator.hasNext();) {
					Object domain = (TreeNode) iterator.next();
					TreeNode child = (TreeNode) domain;
					if (child instanceof DossierNode) {
						if (DroitServiceImpl.getInstance().peutSupprimerByUtilisateurAndChamp(ApplicationContexte.getInstance().getUtilisateur(), "personne")) {
							manager.add(new ActionSupprimer(((DossierNode) child).getPersonne(), DossierEditor.this));
						}
					} else if (child instanceof PrelevementNode) {
						if (DroitServiceImpl.getInstance().peutSupprimerByUtilisateurAndChamp(ApplicationContexte.getInstance().getUtilisateur(), "prelevement")) {
							manager.add(new ActionSupprimer(((PrelevementNode) child).getPrelevement(), DossierEditor.this));
						}
					} else if (child instanceof AnalyseNode) {
						if (DroitServiceImpl.getInstance().peutSupprimerByUtilisateurAndChamp(ApplicationContexte.getInstance().getUtilisateur(), "analyse")) {
							manager.add(new ActionSupprimer(((AnalyseNode) child).getAnalyse(), DossierEditor.this));
						}
					} else if (child instanceof PuceNode) {
						if (DroitServiceImpl.getInstance().peutSupprimerByUtilisateurAndChamp(ApplicationContexte.getInstance().getUtilisateur(), "puce")) {
							manager.add(new ActionSupprimer(((PuceNode) child).getPuce(), DossierEditor.this));
						}

					} else if (child instanceof ResultatNode) {
						if (DroitServiceImpl.getInstance().peutSupprimerByUtilisateurAndChamp(ApplicationContexte.getInstance().getUtilisateur(), "Resultat")) {
							manager.add(new ActionSupprimer(((ResultatNode) child).getResultat(), DossierEditor.this));
						}
					}
				}
			}

		});
		menuMgr.setRemoveAllWhenShown(true);
		treeViewer.getControl().setMenu(menu);

		gFamille = new Group(c, SWT.NONE);
		gFamille.setText("Famille");
		gFamille.setLayoutData(new GridData(SWT.LEFT, SWT.CENTER, true, false, 1, 1));
		gFamille.setLayout(new GridLayout(3, false));

		createFamille();

	}

	private void createFamille() {
		Control[] ctrls = gFamille.getChildren();
		for (Control control : ctrls) {
			control.dispose();
		}
		if (dossierEditorInput.getPersonneCourante().getIdPersonne() != 0) {
			List<Famille> liensFamille = FamilleServiceImpl.getInstance().getFamille(dossierEditorInput.getPersonneCourante().getIdPersonne());
			if (liensFamille != null) {
				for (final Famille famille : liensFamille) {
					final Link personne = new Link(gFamille, SWT.NONE);
					String statut = "";
					// if (famille.getStatut() == 0) {
					// statut = " Statut : inconnu ";
					// }
					// if (famille.getStatut() == 1) {
					// statut = " Statut : atteint ";
					// }
					// if (famille.getStatut() == 2) {
					// statut = " Statut : non atteint ";
					// }
					personne.setText("<a href=\"" + famille.getPersonne().getNom() + " " + famille.getPersonne().getPrenom() /*
																															 * +
																															 * statut
																															 */+ "\">" + famille.getPersonne().getNom() + " " + famille.getPersonne().getPrenom() /*
																																																				 * +
																																																				 * statut
																																																				 */+ "</a>");
					personne.addSelectionListener(new SelectionListener() {

						@Override
						public void widgetSelected(SelectionEvent e) {
							try {
								IEditorInput editorInput = new DossierEditorInput(famille.getPersonne().getIdPersonne());

								PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage().openEditor(editorInput, DossierEditor.ID, true, IWorkbenchPage.MATCH_INPUT);

								IEditorPart editeurActif = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage().getActiveEditor();
								if (editeurActif instanceof DossierEditor) {
									DossierEditor editeur = (DossierEditor) editeurActif;
									if (editeur.getDossierTabItem() != null) {
										editeur.getTabFolder().setSelection(editeur.getDossierTabItem().getTabItem());
									}
								}
							} catch (PartInitException e1) {
								// TODO Auto-generated catch block
								e1.printStackTrace();
							}
						}

						@Override
						public void widgetDefaultSelected(SelectionEvent e) {
							// TODO Auto-generated method stub

						}
					});
					final Link mere = new Link(gFamille, SWT.NONE);
					if (famille.getMere() != null) {
						mere.setText("<a href=\"" + "Mère : " + famille.getMere().getNom() + " " + famille.getMere().getPrenom() + " " + "\">" + "Mère : " + famille.getMere().getNom() + " " + famille.getMere().getPrenom() + "</a>");
					} else {
						mere.setText("<a href=\"" + "Mère : Inconnue " + "\">Mère : Inconnue </a>");

					}
					mere.addSelectionListener(new SelectionListener() {

						@Override
						public void widgetSelected(SelectionEvent e) {
							try {
								IEditorInput editorInput = new DossierEditorInput(famille.getMere().getIdPersonne());

								PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage().openEditor(editorInput, DossierEditor.ID, true, IWorkbenchPage.MATCH_INPUT);

								IEditorPart editeurActif = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage().getActiveEditor();
								if (editeurActif instanceof DossierEditor) {
									DossierEditor editeur = (DossierEditor) editeurActif;
									if (editeur.getDossierTabItem() != null) {
										editeur.getTabFolder().setSelection(editeur.getDossierTabItem().getTabItem());
									}
								}
							} catch (PartInitException e1) {
								// TODO Auto-generated catch block
								e1.printStackTrace();
							}
						}

						@Override
						public void widgetDefaultSelected(SelectionEvent e) {
							// TODO Auto-generated method stub

						}
					});

					final Link pere = new Link(gFamille, SWT.NONE);
					if (famille.getPere() != null) {
						pere.setText("<a href=\"" + "Père : " + famille.getPere().getNom() + " " + famille.getPere().getPrenom() + " " + "\">" + "Père : " + famille.getPere().getNom() + " " + famille.getPere().getPrenom() + "</a>");
					} else {
						pere.setText("<a href=\"" + "Père : Inconnu " + "\">Père : Inconnu </a>");

					}
					pere.addSelectionListener(new SelectionListener() {

						@Override
						public void widgetSelected(SelectionEvent e) {
							try {
								IEditorInput editorInput = new DossierEditorInput(famille.getPere().getIdPersonne());

								PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage().openEditor(editorInput, DossierEditor.ID, true, IWorkbenchPage.MATCH_INPUT);

								IEditorPart editeurActif = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage().getActiveEditor();
								if (editeurActif instanceof DossierEditor) {
									DossierEditor editeur = (DossierEditor) editeurActif;
									if (editeur.getDossierTabItem() != null) {
										editeur.getTabFolder().setSelection(editeur.getDossierTabItem().getTabItem());
									}
								}
							} catch (PartInitException e1) {
								// TODO Auto-generated catch block
								e1.printStackTrace();
							}
						}

						@Override
						public void widgetDefaultSelected(SelectionEvent e) {
							// TODO Auto-generated method stub

						}
					});

				}
			}
			Button btnFamille = new Button(gFamille, SWT.NONE);
			btnFamille.setText("Lier le père ou la mère ");
			btnFamille.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, false, false, 3, 1));
			btnFamille.addSelectionListener(new SelectionListener() {

				@Override
				public void widgetSelected(SelectionEvent e) {
					FamilleDialog familleDialog = new FamilleDialog(Display.getCurrent().getActiveShell(), "Ajouter un membre à la famille", dossierEditorInput.getPersonneCourante());
					if (familleDialog.open() == IDialogConstants.OK_ID) {
						createFamille();
					}

				}

				@Override
				public void widgetDefaultSelected(SelectionEvent e) {
					// TODO Auto-generated method stub

				}

			});
		}
		Label lblPrecision = new Label(gFamille, SWT.NONE);
		lblPrecision.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, true, false, 2, 1));
		lblPrecision.setFont(JFaceResources.getFontRegistry().getBold(JFaceResources.DEFAULT_FONT));
		lblPrecision.setText("Commentaire :");

		tCommentaire = new Text(gFamille, SWT.MULTI | SWT.BORDER | SWT.WRAP | SWT.V_SCROLL);

		GridData gd = new GridData(GridData.FILL, SWT.CENTER, true, true, 3, 3);
		gd.heightHint = 150;
		gd.widthHint = 100;
		tCommentaire.setLayoutData(gd);

		tCommentaire.addModifyListener(new ModifyListener() {
			public void modifyText(ModifyEvent e) {
				setDirty(true);
			}
		});
		if (dossierEditorInput.getPersonneCourante().getCommentaires() != null) {
			tCommentaire.setText(dossierEditorInput.getPersonneCourante().getCommentaires());
		}

		Label lblNonConf = new Label(gFamille, SWT.NONE);
		lblNonConf.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, true, false, 2, 1));
		lblNonConf.setFont(JFaceResources.getFontRegistry().getBold(JFaceResources.DEFAULT_FONT));
		lblNonConf.setText("Non-conformités :");
		listNonConformite = new org.eclipse.swt.widgets.List(gFamille, SWT.BORDER);
		listNonConformite.setToolTipText("Liste des non-conformitées");
		java.util.List<NonConformite> nonConfs = NonConformiteServiceImpl.getInstance().getNonConformiteByIdPersonne(dossierEditorInput.getPersonneCourante().getIdPersonne());
		if (nonConfs != null) {
			for (NonConformite nonConf : nonConfs) {
				String titre = "n°" + nonConf.getIdNonConformite() + "-" + nonConf.getDateObservation().toLocaleString();
				if (nonConf.getType() != null) {
					titre += " " + nonConf.getType().getLibelle();
				}
				if (nonConf.getCategorie() != null) {
					titre += " " + nonConf.getCategorie().getLibelle();
				}
				if (nonConf.getSousCategorie() != null) {
					titre += " " + nonConf.getSousCategorie().getLibelle();
				}
				listNonConformite.add(titre);
			}
		}
		listNonConformite.pack();
		if (DroitServiceImpl.getInstance().peutLireByUtilisateurAndChamp(ApplicationContexte.getInstance().getUtilisateur(), "nonConf")) {

			listNonConformite.addMouseListener(new MouseListener() {

				public void mouseUp(MouseEvent e) {
				}

				public void mouseDown(MouseEvent e) {
				}

				public void mouseDoubleClick(MouseEvent e) {
					String[] titres = listNonConformite.getSelection();
					String idNonConf = titres[0].substring(2, titres[0].indexOf("-"));
					NonConformite nonConf = NonConformiteServiceImpl.getInstance().getNonConformiteById(Integer.parseInt(idNonConf));
					if (nonConf != null) {
						NonConformiteDialog nonConformiteDialog = new NonConformiteDialog(nonConf);
						nonConformiteDialog.open();
					}
				}
			});
		}

		btnAjouterUneNonConf = new Button(gFamille, SWT.NONE);
		btnAjouterUneNonConf.setImage(ResourceManager.getPluginImage("visiopuce", "icons/nonConf.jpg"));
		btnAjouterUneNonConf.setToolTipText("Ajouter une non-conformité");
		if (DroitServiceImpl.getInstance().peutCreerByUtilisateurAndChamp(ApplicationContexte.getInstance().getUtilisateur(), "nonConf")) {
			btnAjouterUneNonConf.addSelectionListener(new SelectionAdapter() {
				public void widgetSelected(SelectionEvent e) {

					NonConformite nonConf = new NonConformite();
					nonConf.setPersonne(dossierEditorInput.getPersonneCourante());
					NonConformiteDialog nonConformiteDialog = new NonConformiteDialog(nonConf);
					nonConformiteDialog.open();
				}
			});
		}
		if (btnAjouterUneNonConf != null) {
			btnAjouterUneNonConf.setEnabled(DroitServiceImpl.getInstance().peutCreerByUtilisateurAndChamp(ApplicationContexte.getInstance().getUtilisateur(), "nonConf"));

		}
		gFamille.pack();
	}

	protected boolean isModifiable() {
		return isModifiable;
	}

	public void setModifiable(boolean isModifiable) {
		refresh();
		if (isModifiable) {
			if (!this.isModifiable) {
				Utilisateur utilisateur = EnModifServiceImpl.getInstance().isEnModif(dossierEditorInput.getPersonneCourante().getIdPersonne());
				if (utilisateur == null) {
					tCommentaire.setEnabled(DroitServiceImpl.getInstance().peutModifierByUtilisateurAndChamp(ApplicationContexte.getInstance().getUtilisateur(), "personne"));
					dossierTabItem.setModifiable(true);
					for (int mapKey : prelevementTabItems.keySet()) {
						PrelevementTabItem prelevementTabItem = prelevementTabItems.get(mapKey);
						prelevementTabItem.setModifiable(true);
					}
					for (int mapKey : analyseTabItems.keySet()) {
						AnalyseTabItem analyseTabItem = analyseTabItems.get(mapKey);
						analyseTabItem.setModifiable(true);
					}
					for (int mapKey : cnvTabItems.keySet()) {
						CNVTabItem cnvTabItem = cnvTabItems.get(mapKey);
						cnvTabItem.setModifiable(true);
					}
					for (int mapKey : puceTabItems.keySet()) {
						PuceTabItem puceTabItem = puceTabItems.get(mapKey);
						puceTabItem.setModifiable(true);
					}
					EnModifServiceImpl.getInstance().passerEnModif(dossierEditorInput.getPersonneCourante());
					itemModifier.setToolTipText("Dossier en édition, cliquez ici pour passer en mode lecture seule");
					itemModifier.setImage(ResourceManager.getPluginImage("visiopuce", "icons/unlock.jpg"));
					this.isModifiable = true;
				} else {
					MessageDialog.openError(Display.getCurrent().getActiveShell(), "Dossier bloqué", "Ce dossier est déjà ouvert par " + utilisateur.getPrenom() + " " + utilisateur.getNom() + ". Il est impossible de passer en mode écriture.");
				}
			}
		} else {
			if (this.isModifiable) {
				if (isDirty()) {

					MessageDialog.openError(Display.getCurrent().getActiveShell(), "Dossier non sauvegardé", "Des changements ont été apportés au dossier, il est impossible de passer en mode lecture seule sans avoir sauvegardé le dossier.");
				} else {
					tCommentaire.setEnabled(false);
					dossierTabItem.setModifiable(false);
					for (int mapKey : prelevementTabItems.keySet()) {
						PrelevementTabItem prelevementTabItem = prelevementTabItems.get(mapKey);
						prelevementTabItem.setModifiable(false);
					}
					for (int mapKey : analyseTabItems.keySet()) {
						AnalyseTabItem analyseTabItem = analyseTabItems.get(mapKey);
						analyseTabItem.setModifiable(false);
					}
					for (int mapKey : cnvTabItems.keySet()) {
						CNVTabItem cnvTabItem = cnvTabItems.get(mapKey);
						cnvTabItem.setModifiable(false);
					}
					for (int mapKey : puceTabItems.keySet()) {
						PuceTabItem puceTabItem = puceTabItems.get(mapKey);
						puceTabItem.setModifiable(false);
					}
					EnModifServiceImpl.getInstance().supprimerEnModif(dossierEditorInput.getPersonneCourante());
					itemModifier.setToolTipText("Dossier en lecture seule, cliquez ici pour passer en mode écriture");
					itemModifier.setImage(ResourceManager.getPluginImage("visiopuce", "icons/lock.jpg"));
					this.isModifiable = false;
				}
			}
		}
	}

	private void refresh() {
		if (dossierEditorInput != null && dossierEditorInput.getPersonneCourante() != null) {
			if (!isModifiable) {
				dossierEditorInput.setPersonneCourante(PersonneServiceImpl.getInstance().refresh(dossierEditorInput.getPersonneCourante()));
				if (dossierTabItem != null) {
					dossierTabItem.remplir(dossierEditorInput.getPersonneCourante());
					for (int mapKey : prelevementTabItems.keySet()) {
						PrelevementTabItem prelevementTabItem = prelevementTabItems.get(mapKey);
						prelevementTabItem.remplir(PrelevementServiceImpl.getInstance().refresh(prelevementTabItem.getPrelevement()));
					}
					for (int mapKey : analyseTabItems.keySet()) {
						AnalyseTabItem analyseTabItem = analyseTabItems.get(mapKey);
						analyseTabItem.remplir(AnalyseServiceImpl.getInstance().refresh(analyseTabItem.getAnalyse()));
					}
					for (int mapKey : cnvTabItems.keySet()) {
						CNVTabItem cnvTabItem = cnvTabItems.get(mapKey);
						cnvTabItem.remplir(AlterationServiceImpl.getInstance().refresh(cnvTabItem.getCNV()));
					}
					for (int mapKey : puceTabItems.keySet()) {
						PuceTabItem puceTabItem = puceTabItems.get(mapKey);
						puceTabItem.remplir(PuceServiceImpl.getInstance().refresh(puceTabItem.getPuce()));
					}
				}
			}
		}
	}

	public ToolItem getItemModifier() {
		return itemModifier;
	}

	public void setItemModifier(ToolItem itemModifier) {
		this.itemModifier = itemModifier;
	}

	@Override
	public void setFocus() {
		// TODO Auto-generated method stub

	}

	@Override
	public void doSave(IProgressMonitor monitor) {
		boolean aSauver = true;
		boolean voirCotation = false;
		if (isDirty) {
			Personne personne = dossierTabItem.recupererObjet();
			if (personne != null) {
				personne.setCommentaires(tCommentaire.getText());
			}
			HashMap<Integer, Prelevement> prelevements = new HashMap<Integer, Prelevement>();
			HashMap<Integer, Analyse> analyses = new HashMap<Integer, Analyse>();
			HashMap<Integer, Resultat> resultats = new HashMap<Integer, Resultat>();
			HashMap<Integer, Puce> puces = new HashMap<Integer, Puce>();
			HashMap<Integer, Alteration> alterations = new HashMap<Integer, Alteration>();

			List<RenduPuce> renduPuces = new ArrayList<RenduPuce>();
			List<RenduFish> renduFishs = new ArrayList<RenduFish>();
			List<RenduBiomol> renduBiomols = new ArrayList<RenduBiomol>();
			List<ExpFish> expFishs = new ArrayList<ExpFish>();
			List<ZoneTesteeBiomol> zoneTestees = new ArrayList<ZoneTesteeBiomol>();
			List<VerifBiomol> verifBiomols = new ArrayList<VerifBiomol>();
			List<VerifFish> verifFishs = new ArrayList<VerifFish>();

			if (personne != null) {

				for (int mapKey : prelevementTabItems.keySet()) {
					PrelevementTabItem prelevementTabItem = prelevementTabItems.get(mapKey);
					Prelevement p = prelevementTabItem.recupererObjet();
					if (p != null) {
						prelevements.put(mapKey, p);
					} else {
						aSauver = false;
						break;
					}
				}

				if (aSauver) {
					for (int mapKey : puceTabItems.keySet()) {
						PuceTabItem puceTabItem = puceTabItems.get(mapKey);
						Puce p = puceTabItem.recupererObjet();
						if (p != null) {
							puces.put(mapKey, p);
						} else {
							aSauver = false;
							break;
						}
					}
				}
				if (aSauver) {
					for (int mapKey : analyseTabItems.keySet()) {
						AnalyseTabItem analyseTabItem = analyseTabItems.get(mapKey);
						Analyse a = analyseTabItem.recupererObjet();
						if (a != null) {
							if (a.getIdAnalyse() == 0 && a.getTypeAnalyse().getLibelle().equals("puce")) {
								newp = new Puce();
								newp.setAnalyse(a);
								newp.setIdPuce(0);
								newp.setSexePuce("I");
								newp.setSupprimer(false);
								addPuceTabItem(newp);
							}
							analyses.put(mapKey, a);
							Resultat r = analyseTabItem.recupererObjetResultat();
							if (r != null) {
								resultats.put(mapKey, r);
							}
							// puce
							if (a.getTypeAnalyse().getIdTypeAnalyse() == 3) {
								RenduPuce rp = analyseTabItem.recupererRenduPuce();
								if (rp != null) {
									renduPuces.add(rp);
								}
							}
							// FISH
							if (a.getTypeAnalyse().getIdTypeAnalyse() == 2) {
								Object[] rf_expFish = analyseTabItem.recupererRenduFishExpFish();
								if (rf_expFish != null && rf_expFish.length == 3) {
									RenduFish rf = (RenduFish) rf_expFish[0];
									List<VerifFish> listeVerifFish = (ArrayList<VerifFish>) rf_expFish[1];
									List<ExpFish> listeExpFish = (ArrayList<ExpFish>) rf_expFish[2];
									renduFishs.add(rf);
									verifFishs.addAll(listeVerifFish);
									if (listeExpFish != null) {
										expFishs.addAll(listeExpFish);
									}
								}
							}
							// qPCR
							if (a.getTypeAnalyse().getIdTypeAnalyse() == 4) {
								Object[] rq_zone = analyseTabItem.recupererRenduBiomolZoneTestee();
								if (rq_zone != null && rq_zone.length == 3) {
									RenduBiomol rq = (RenduBiomol) rq_zone[0];
									List<VerifBiomol> listeVerifBM = (ArrayList<VerifBiomol>) rq_zone[1];
									List<ZoneTesteeBiomol> listeZone = (ArrayList<ZoneTesteeBiomol>) rq_zone[2];
									renduBiomols.add(rq);
									verifBiomols.addAll(listeVerifBM);
									if (listeZone != null) {
										zoneTestees.addAll(listeZone);
									}
								}
							}

						} else {
							aSauver = false;
							break;
						}
					}
				}
				if (aSauver) {
					for (int mapKey : cnvTabItems.keySet()) {
						CNVTabItem cnvTabItem = cnvTabItems.get(mapKey);
						Alteration a = cnvTabItem.recupererObjet();
						if (a != null) {
							alterations.put(mapKey, a);
						} else {
							aSauver = false;
							break;
						}
					}
				}
			} else {
				aSauver = false;
			}
			if (aSauver) {

				for (int mapKey : alterations.keySet()) {
					Alteration cnv = alterations.get(mapKey);
					try {
						AlterationServiceImpl.getInstance().save(cnv);
						cnvTabItems.get(mapKey).remplir(cnv);
					} catch (Exception e) {
						MessageDialog.openError(Display.getCurrent().getActiveShell(), "Problème d'enregistrement", "Erreur d'enregistrement du CNV");
						System.out.println(e);
					}

				}
				for (int mapKey : prelevements.keySet()) {

					Prelevement prelevement = prelevements.get(mapKey);
					try {
						PrelevementServiceImpl.getInstance().save(prelevement);
						prelevementTabItems.get(mapKey).remplir(prelevement);
					} catch (Exception e) {
						MessageDialog.openError(Display.getCurrent().getActiveShell(), "Problème d'enregistrement", "Erreur d'enregistrement du prélèvement " + prelevement.getNumeroPrelevement());
						System.out.println(e);
					}
				}
				for (int mapKey : analyses.keySet()) {
					Analyse analyse = analyses.get(mapKey);

					try {
						boolean savePuce = false;
						if (analyse.getIdAnalyse() == 0 && newp != null) {
							savePuce = true;
						}
						AnalyseServiceImpl.getInstance().save(analyse);
						analyseTabItems.get(mapKey).remplir(analyse);
						if (newp != null && savePuce) {
							newp.setAnalyse(analyse);
							PuceServiceImpl.getInstance().save(newp);
						}
						analyseTabItems.get(mapKey).remplir(analyse);
					} catch (Exception e) {
						MessageDialog.openError(Display.getCurrent().getActiveShell(), "Problème d'enregistrement", "Erreur d'enregistrement de l'analyse ");
						System.out.println(e);
					}

				}
				for (int mapKey : puces.keySet()) {
					Puce puce = puces.get(mapKey);

					try {
						PuceServiceImpl.getInstance().save(puce);
						puceTabItems.get(mapKey).remplir(puce);
					} catch (Exception e) {
						MessageDialog.openError(Display.getCurrent().getActiveShell(), "Problème d'enregistrement", "Erreur d'enregistrement de la puce");
						System.out.println(e);
					}

				}
				for (int mapKey : resultats.keySet()) {
					Resultat resultat = resultats.get(mapKey);

					try {
						ResultatServiceImpl.getInstance().save(resultat);
						if (resultat.isRendre()) {
							voirCotation = true;
						}
					} catch (Exception e) {
						MessageDialog.openError(Display.getCurrent().getActiveShell(), "Problème d'enregistrement", "Erreur d'enregistrement du résultat");
						System.out.println(e);
					}

				}
				for (RenduBiomol renduBiomol : renduBiomols) {
					try {
						ResultatServiceImpl.getInstance().save(renduBiomol);
					} catch (Exception e) {
						MessageDialog.openError(Display.getCurrent().getActiveShell(), "Problème d'enregistrement", "Erreur d'enregistrement du rendu qPCR");
						System.out.println(e);
					}

				}
				for (RenduFish renduFish : renduFishs) {
					try {
						ResultatServiceImpl.getInstance().save(renduFish);

					} catch (Exception e) {
						MessageDialog.openError(Display.getCurrent().getActiveShell(), "Problème d'enregistrement", "Erreur d'enregistrement du rendu FISH");
						System.out.println(e);
					}

				}
				for (RenduPuce renduPuce : renduPuces) {
					try {
						ResultatServiceImpl.getInstance().save(renduPuce);

					} catch (Exception e) {
						MessageDialog.openError(Display.getCurrent().getActiveShell(), "Problème d'enregistrement", "Erreur d'enregistrement du rendu puce");
						System.out.println(e);
					}

				}

				for (VerifFish verifFish : verifFishs) {

					try {
						ResultatServiceImpl.getInstance().save(verifFish);

					} catch (Exception e) {
						MessageDialog.openError(Display.getCurrent().getActiveShell(), "Problème d'enregistrement", "Erreur d'enregistrement d'une expérience FISH");
						System.out.println(e);
					}

				}
				for (VerifBiomol verifBiomol : verifBiomols) {

					try {
						ResultatServiceImpl.getInstance().save(verifBiomol);

					} catch (Exception e) {
						MessageDialog.openError(Display.getCurrent().getActiveShell(), "Problème d'enregistrement", "Erreur d'enregistrement d'une expérience FISH");
						System.out.println(e);
					}

				}

				for (ZoneTesteeBiomol zoneTestee : zoneTestees) {
					try {
						ResultatServiceImpl.getInstance().save(zoneTestee);

					} catch (Exception e) {
						MessageDialog.openError(Display.getCurrent().getActiveShell(), "Problème d'enregistrement", "Erreur d'enregistrement d'une zone testée par qPCR");
						System.out.println(e);
					}

				}
				for (ExpFish expFish : expFishs) {

					try {
						ResultatServiceImpl.getInstance().save(expFish);

					} catch (Exception e) {
						MessageDialog.openError(Display.getCurrent().getActiveShell(), "Problème d'enregistrement", "Erreur d'enregistrement d'une expérience FISH");
						System.out.println(e);
					}

				}

				try {
					PersonneServiceImpl.getInstance().save(personne);
					dossierTabItem.remplir(personne);
					dossierEditorInput.setPersonneCourante(personne);
					setPartName(dossierEditorInput.getName());
				} catch (Exception e) {
					MessageDialog.openError(Display.getCurrent().getActiveShell(), "Problême d'enregistrement", "Erreur d'enregistrement de la personne " + personne.getNom());
					e.printStackTrace();
				}
				setDirty(false);
				treeViewer.setInput(new DossierNode(dossierEditorInput.getPersonneCourante()));
				// treeViewer.refresh();
				treeViewer.expandAll();
				// if (ApplicationContexte.getInstance().getRechercheEnCours()
				// != null) {
				// try {
				// PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage().showView("visiopuce.resultatRechercheDossierView");
				// ResultatRechercheView view = (ResultatRechercheView)
				// PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage().findView("visiopuce.resultatRechercheDossierView");
				// view.refresh();
				// } catch (PartInitException e) {
				// // TODO Auto-generated catch block
				// e.printStackTrace();
				// }
				// }
			}
		}
		if (voirCotation) {
			CotationDialog cotationDialog = new CotationDialog(getSite().getShell(), dossierEditorInput.getPersonneCourante(), "Vous venez d'enregistrer le résultat, merci de valider la cotation du dossier.");
			cotationDialog.open();
		}
	}

	@Override
	public void doSaveAs() {
		doSave(null);

		EnModifServiceImpl.getInstance().supprimerEnModif(dossierEditorInput.getPersonneCourante());
	}

	@Override
	public void init(IEditorSite site, IEditorInput input) throws PartInitException {
		if (!(input instanceof DossierEditorInput)) {
			throw new PartInitException("Mauvaise entrée ça doit être un DossierEditorInput");
		}
		prelevementTabItems = new HashMap<Integer, PrelevementTabItem>();
		analyseTabItems = new HashMap<Integer, AnalyseTabItem>();
		cnvTabItems = new HashMap<Integer, CNVTabItem>();
		puceTabItems = new HashMap<Integer, PuceTabItem>();

		dossierEditorInput = (DossierEditorInput) input;

		setSite(site);
		setInput(input);
		setPartName(dossierEditorInput.getName());
	}

	@Override
	public boolean isDirty() {
		return isDirty;
	}

	@Override
	public boolean isSaveAsAllowed() {
		// TODO Auto-generated method stub
		return false;
	}

	protected void setDirty(boolean isDirty) {
		if (isDirty) {
			itemSave.setEnabled(true);
		} else {
			itemSave.setEnabled(false);
		}
		if (isModifiable()) {
			this.isDirty = isDirty;
			firePropertyChange(PROP_DIRTY);
		}
	}

	public void partActivated(IWorkbenchPartReference partRef) {
		// TODO Auto-generated method stub

	}

	public void partBroughtToTop(IWorkbenchPartReference partRef) {
		// TODO Auto-generated method stub

	}

	public void partClosed(IWorkbenchPartReference partRef) {
		EnModifServiceImpl.getInstance().supprimerEnModif(dossierEditorInput.getPersonneCourante());
	}

	public void partDeactivated(IWorkbenchPartReference partRef) {
		// TODO Auto-generated method stub

	}

	public void partOpened(IWorkbenchPartReference partRef) {
		// TODO Auto-generated method stub

	}

	public void partHidden(IWorkbenchPartReference partRef) {
		// TODO Auto-generated method stub

	}

	public void partVisible(IWorkbenchPartReference partRef) {
		// TODO Auto-generated method stub

	}

	public void partInputChanged(IWorkbenchPartReference partRef) {
		// TODO Auto-generated method stub

	}

	public void refreshTreeView() {
		treeViewer.setInput(new DossierNode(dossierEditorInput.getPersonneCourante()));
		treeViewer.expandAll();
	}

}